package reservation.v2;

import java.io.*;
import java.text.*;
import java.util.*;

/**
 * Classe SerializeText : Enregistrement de données dans un fichier texte
 * 
 * @author Alexandre Boursier and Jerome Boursier
 * @version 2011.11.20
 */

public abstract class SerializeText {

    /**
     * Liste des trajets
     */
    private static List<Trajet> trajets = new LinkedList<Trajet>();

    /**
     * Liste des transports 
     */
    private static List<Transport> transports = new LinkedList<Transport>();

    /**
     * Nom du fichier dans lequel seront enregistrées les données de réservation, transport et trajet
     */
    private static final String fichier = "Reservations_v2.txt";

    /**
     * Utiliser le délimitateur pour la création d'objets
     */
    private static final String separator = ";";

    /**
     * Fermer le flux de sérialisation courant
     * 
     */
    public static void close()
    {
        trajets.clear();
        transports.clear();
    }

    /**
     * Charger un trajet : l'ajouter à la liste des trajets
     * 
     * @param t
     *            Trajet à charger
     */
    public static void loadTrajet(Trajet t) {
        trajets.add(t);
    }

    /**
     * Charger un transport : l'ajouter à la liste des transports
     * 
     * @param t
     *            Transport à charger
     */
    public static void loadTransport(Transport t) {
        transports.add(t);
    }

    /**
     * Liste des trajets
     */
    public static String listeTrajets() {
        StringBuilder sb = new StringBuilder();
        for (Trajet t : trajets) {
            sb.append(t.toString());
        }
        return sb.toString();
    }

    /**
     * Liste des transports
     */
    public static String listeTransports() {
        StringBuilder sb = new StringBuilder();
        for (Transport t : transports) {
            sb.append(t.toString());
        }
        return sb.toString();
    }

    /** 
     *  Créer un nouveau fichier de données vierge à partir de son chemin
     *  
     *  @return true si le fichier est créé, false sinon
     * @throws IOException 
     * @throws NullPointerException 
     */
    public static boolean creerFichier() throws IOException {
        // Obtenir une description du fichier a créer
        File f = new File(fichier);

        // Contrôler l'éventuelle existence du fichier
        if (f.exists())
            f.delete();

        // Créer le fichier
        try {f.createNewFile();}
        catch(IOException e){return false;}

        return true;
    }

    /** 
     * Creér une chaîne de caractères à partir d'un tableau de chaînes et d'un separateur
     * 
     * @param att 
     *          La liste contenant les attributs cibles
     * @param separator
     *          Le séparateur cible  
     * @return la chaîne résultante    
     */
    public static String creerChaine(List<String> att) {
        // Controler la validité des paramètres
        if(att.size() == 0)
            throw new NullPointerException();

        // Créer la chaîne de caractères resultante en concatenant
        // les éléments de la liste
        StringBuilder sb = new StringBuilder();
        Iterator<String> iter = att.iterator();
        while (iter.hasNext()) {
            String s = iter.next();
            sb.append(s);
            sb.append(separator);
        }

        // Renvoyer le resultat
        return sb.toString();
    }

    /**
     * Récupérer la ligne d'un fichier dans un tableau pour la reconnaissance
     * d'attributs et mots-clés
     * @param buffer
     *          La ligne cible
     * @return un tableau d'attributs et de mots-clés d'une ligne d'un fichier
     */
    public static String[] getChaine(String buffer)
    {
        // Decouper la ligne lue
        StringTokenizer st = new StringTokenizer(buffer, separator);

        // Stocker chaque champ de la ligne dans un tableau
        String[] token = new String[st.countTokens()];
        for(int i=0; i<token.length; i++)
            token[i] = st.nextToken();

        return token;
    }

    /** 
     * Contrôler l'existence d'un fichier à partir de son chemin
     * 
     * @param path
     *          Le chemin du fichier cible
     */
    public static boolean isExist() {

        // Obtenir une description du fichier a créer
        File f = new File(fichier);

        // Contrôler l'existence du fichier
        if (f.exists())
            return true;
        else return false;
    }

    /** 
     *  Ecrire une chaîne de caractères à la fin d'un fichier
     *  
     *  @param line
     *          La chaîne à inclure dans le fichier
     * @throws IOException 
     * @throws StartStopException 
     * @throws NegativeValueException 
     * @throws NumberFormatException 
     */
    public static boolean store(String line) throws NullPointerException, IOException, 
    NumberFormatException, NegativeValueException, StartStopException {
        // Contrôler la validité des paramètres
        if(line == null)
            throw new NullPointerException();

        // Contrôler l'existence du fichier
        if(!isExist())
            throw new FileNotFoundException();

        // Initialiser la lecture du fichier
        FileReader fr = null;
        try {fr = new FileReader(fichier);}
        catch(IOException e){return false;}
        BufferedReader br = new BufferedReader(fr);

        // Initialiser l'ecriture dans le fichier
        FileWriter fw = null;
        try {fw = new FileWriter(fichier, true);}
        catch(IOException e){return false;}
        BufferedWriter bw = new BufferedWriter(fw);

        // Parcourir l'ensemble du fichier
        String buffer = null;
        do {
            try {buffer = br.readLine();}
            catch(IOException e){return false;}
        } while(buffer != null);

        // Ecrire la chaine passee en parametre dans le fichier
        // et effectuer un passage a la ligne
        try {
            bw.write(line + "\n");  
        }
        catch(IOException e){return false;}
        // Terminer la lecture et l'ecriture du fichier
        try {
            bw.close(); fw.close();
            br.close(); fr.close();
        }
        catch(IOException e){return false;}
        return true;
    }

    /**
     * Overloading store : Méthode store pour l'objet de type transport
     * 
     * @param t
     *          Le transport à ajouter dans le fichier texte
     */
    public static boolean store(Transport t) throws NumberFormatException, NullPointerException, 
    IOException, NegativeValueException, StartStopException
    {
        // Créer une chaîne qui sera la future dernière ligne du fichier
        if(store(SerializeText.creerChaine(t.parse())))
        {
            // Ajouter le transport à la liste des transports courants
            SerializeText.loadTransport(t);
            return true;
        }
        return false;
    }

    /**
     * Overloading : Méthode store pour l'objet de type transport
     * 
     * @param t
     *          Le trajet à ajouter dans le fichier texte
     */
    public static boolean store(Trajet t) throws NumberFormatException, NullPointerException, 
    IOException, NegativeValueException, StartStopException
    {
        // Créer une chaîne qui sera la future dernière ligne du fichier
        if(store(SerializeText.creerChaine(t.parse())))
        {
            // Enregistrer tous les clients correspondants au trajet initialement créé
            for(Client c : t.getVoyageurs())
            {
                // Parser l'objet client
                List<String> attributs = c.parse();
                attributs.add(String.valueOf(t.getIdentTrajet()));
                if(!store(SerializeText.creerChaine(attributs)))
                    return false;
            }
            // Ajouter le trajets à la liste des trajets courants
            SerializeText.loadTrajet(t);
            return true;
        }
        return false;
    }

    /**
     *  Overloading store : Ajouter un client dans un trajet donné
     *  
     * @param c 
     *          Le client cible
     * @parem t
     *          Le trajet cible
     * 
     * @return true si le voyageur est bien ajouté, false sinon (existe déjà)
     * @throws IOException 
     *  
     */
    public static boolean store(Client c, Trajet t) throws IOException
    {
        if(t.exists(c))
        {
            System.out.println("Le client d'identifiant " + c.getIdentifiant() + " est déjà inscrit");
            return false;
        }  
        if(!t.existPlaces())
        {
            System.out.println("Il ne reste plus de places disponibles pour ce trajet");
            return false;
        }

        // Contrôler la validité des paramètres
        if(c == null || t == null)
            throw new NullPointerException();

        // Contrôler l'existence du fichier
        if(!isExist())
            throw new FileNotFoundException();

        // Initialiser la lecture du fichier
        FileReader fr = null;
        try {fr = new FileReader(fichier);}
        catch(IOException e){System.out.println("aie");return false;}
        BufferedReader br = new BufferedReader(fr);

        // Initialiser l'ecriture dans le fichier
        FileWriter fw = null;
        try {fw = new FileWriter(fichier, true);}
        catch(IOException e){return false;}
        BufferedWriter bw = new BufferedWriter(fw);

        // Parcourir l'ensemble du fichier
        String buffer = null;
        do {
            try {buffer = br.readLine();}
            catch(IOException e){return false;}
        } while(buffer != null);


        List<String> attributs = c.parse();
        attributs.add(String.valueOf(t.getIdentTrajet()));
        bw.write(SerializeText.creerChaine(attributs) + "\n"); 

        // Terminer la lecture et l'ecriture du fichier
        //
        try {
            bw.close(); fw.close();
            br.close(); fr.close();
        }
        catch(IOException e){return false;}

        for(Trajet tr : trajets)
        {
            if (tr.getIdentTrajet() == t.getIdentTrajet())
                tr.getVoyageurs().add(c);
        }
        return true;
    }

    /**
     *  Charger la liste des transports et des trajets
     *  
     *  @param separator 
     *          Le délimitateur cible
     * @throws NegativeValueException 
     * @throws NumberFormatException 
     * @throws StartStopException 
     * @throws IOException 
     * @throws ParseException 
     */
    public static boolean load() throws NullPointerException, NumberFormatException
    , NegativeValueException, StartStopException, IOException, ParseException {

        // Trier le fichier pour obenir un ordre logique de récupération d'objets
        SerializeText.ecrireLignes(SerializeText.recupererLignesOrdonnees());

        // Contrôler la validité des paramètres
        if(separator == null)
            throw new NullPointerException();

        // Contrôler l'existence du fichier
        if(!isExist())
            throw new FileNotFoundException();

        // Definir un scanner sur le fichier
        Scanner scan = null;
        try{scan = new Scanner(new File(fichier));}
        catch(FileNotFoundException e){return false;}

        String buffer = null;

        // Parcourir l'ensemble du fichier
        while(scan.hasNextLine()) {

            // Lire la ligne courante du fichier
            buffer = scan.nextLine();

            String[] token = SerializeText.getChaine(buffer);

            if (token[0].equals("TRANSPORT"))
            {
                // Créer le transport associé 
                Transport t = new Transport(Integer.parseInt(token[1]),TypeTransport.valueOf(token[2]), 
                        Integer.parseInt(token[3]));

                // Ajouter le transport à la liste
                SerializeText.loadTransport(t);
            }
            else if (token[0].equals("TRAJET"))
            {
                Transport tCible = null;
                // Trouver le transport associé au trajet
                for(Transport t : transports)
                {
                    if (t.getIdentTransport() == Integer.parseInt(token[5]))
                        tCible = t;
                }

                List<Client> cCible = new ArrayList<Client>();
                // Créer le trajet associé
                Trajet t = new Trajet(Integer.parseInt(token[1]),Ville.valueOf(token[2]), Ville.valueOf(token[3]),
                        Trajet.toFormatedDate(token[4]),tCible, cCible);

                // Ajouter le transport à la liste
                SerializeText.loadTrajet(t);
            }
            else if (token[0].equals("VOYAGEUR"))
            {
                // Récupérer le dernier trajet de la liste qui correspond au trajet cible et ajouter
                // le participant au voyage
                for (Trajet t : trajets)
                {
                    if (t.getIdentTrajet() == Integer.parseInt(token[4]))
                    {
                        t.getVoyageurs()
                        .add(new Client(token[1],token[2],token[3]));
                    }
                }

            }
        }
        return true;
    }

    /**
     * Supprimer le voyageur cible dans le trajet cible
     * @param c
     *          Le client recherche
     * @param t
     *          Le trajet cible
     * @return  true si le voyageur est supprimé, false sinon (le voyageur n'existe pas dans le trajet)
     * @throws NumberFormatException
     * @throws NullPointerException
     * @throws IOException
     * @throws NegativeValueException
     * @throws StartStopException
     */
    public static boolean delete(Client c, Trajet t) throws NumberFormatException, NullPointerException,
    IOException, NegativeValueException, StartStopException
    {
        List<String> traitement = SerializeText.recupererLignesOrdonnees();

        for(String s : traitement)
        {
            String[] token = SerializeText.getChaine(s);

            // Chercher le client cible dans le trajet cible
            if(token.length > 4 && token[0].equals("VOYAGEUR") && token[1].equals(String.valueOf(c.getIdentifiant())) 
                    && token[4].equals(String.valueOf(t.getIdentTrajet())))
            {
                // Supprimer le client cible
                traitement.remove(s);
                // Supprimer le client de la liste courante de la classe éponyme
                for(Trajet tr : trajets)
                {
                    // Vérifier que c'est le bon trajet
                    if(tr.getIdentTrajet() == t.getIdentTrajet())
                    {
                        // Parcourir la liste des clients cibles
                        for(Client cl : tr.getVoyageurs())
                        {
                            // Vérifier que c'est le bon client
                            if(cl.getIdentifiant() == c.getIdentifiant())
                            {
                                // Supprimer le client de la liste
                                tr.getVoyageurs().remove(cl);
                            }
                        }
                    }
                }
                // Recharger le fichier sans le client
                SerializeText.ecrireLignes(traitement);
                return true;
            }
        }
        System.out.println("Le client d'identifiant " + c.getIdentifiant() + "" +
                " n'a pas été trouvé dans ce trajet");
        return false;
    }

    /**
     * Supprimer le trajet cible
     * @param t
     *          Le trajet cible
     * @return  true si le trajet existe, false sinon
     * @throws NumberFormatException
     * @throws NullPointerException
     * @throws IOException
     * @throws NegativeValueException
     * @throws StartStopException
     */
    public static boolean delete(Trajet t) throws NumberFormatException, NullPointerException,
    IOException, NegativeValueException, StartStopException
    {
        List<String> traitement = SerializeText.recupererLignesOrdonnees();

        Iterator<String> it = traitement.iterator();
        // Supprimer tous les voyageurs associés
        while(it.hasNext())
        {
            String s = it.next();
            String[] token = SerializeText.getChaine(s);

            if(token[0].equals("VOYAGEUR") && token[4].equals(String.valueOf(t.getIdentTrajet())))
            { 
                it.remove();
            }
        }
        for(String s : traitement)
        {
            String[] token = SerializeText.getChaine(s);

            // Chercher le trajet cible
            if(token[0].equals("TRAJET") && token[1].equals(String.valueOf(t.getIdentTrajet())))
            {
                // Supprimer le trajet cible
                traitement.remove(s);
                // Supprimer le trajet de la liste cible de la classe éponyme
                trajets.remove(SerializeText.getTrajetById(Integer.parseInt(token[1])));
                // Recharger le fichier sans les champs précités
                SerializeText.ecrireLignes(traitement);
                return true;
            }
        }
        System.out.println("Le trajet n'a pas été trouvé dans ce trajet");
        return false;
    }

    /**
     * Supprimer le transport cible
     * @param t
     *          Le transport cible
     * @return true si le transport existe, false sinon
     * @throws NumberFormatException
     * @throws NullPointerException
     * @throws IOException
     * @throws NegativeValueException
     * @throws StartStopException
     */
    public static boolean delete(Transport t) throws NumberFormatException, NullPointerException,
    IOException, NegativeValueException, StartStopException
    {
        List<String> traitement = SerializeText.recupererLignesOrdonnees();

        for(String s : traitement)
        {
            String[] token = SerializeText.getChaine(s);

            // Trouver les trajets associés
            if(token[0].equals("TRAJET") && token[5].equals(String.valueOf(t.getIdentTransport())))
            {
                Trajet toDelete = SerializeText.getTrajetById(Integer.parseInt(token[1]));
                SerializeText.delete(toDelete);
            }
        }

        // Recharger le fichier après changement
        traitement = SerializeText.recupererLignesOrdonnees();

        for(String s : traitement)
        {
            String[] token = SerializeText.getChaine(s);

            // Chercher le transport cible
            if(token[0].equals("TRANSPORT") && token[1].equals(String.valueOf(t.getIdentTransport())))
            {
                // Supprimer le transport cible
                traitement.remove(s);
                Transport transp = SerializeText.getTransportById(t.getIdentTransport());
                // Supprimer le transport de la liste cible de la classe éponyme
                transports.remove(transp);
                // Recharger le fichier sans les champs précités
                SerializeText.ecrireLignes(traitement);
                return true;
            }
        }
        System.out.println("Le trajet recherché n'existe pas !");
        return false;
    }

    /**
     * Modifier le transport cible
     * @param t
     *          Le transport cible
     * @return
     * @throws NumberFormatException
     * @throws NullPointerException
     * @throws IOException
     * @throws NegativeValueException
     * @throws StartStopException
     */
    public static boolean alter(Transport t) throws NumberFormatException, NullPointerException, IOException,
    NegativeValueException, StartStopException
    {
        List<String> traitement = SerializeText.recupererLignesOrdonnees();

        for(String s : traitement)
        {
            String[] token = SerializeText.getChaine(s);
            // Trouver la ligne cible
            if(token[0].equals("TRANSPORT") && token[1].equals(String.valueOf(t.getIdentTransport())))
            {
                // Supprimer la ligne
                traitement.remove(s);
                // Ajouter la nouvelle ligne
                traitement.add(SerializeText.creerChaine(t.parse()));  
                // Recharger le fichier sans les champs précités
                SerializeText.ecrireLignes(traitement);
                SerializeText.ecrireLignes(SerializeText.recupererLignesOrdonnees());
                return true;
            }
        }
        return false;
    }

    /**
     * Modifier le trajet cible
     * @param t
     *          Le trajet cible
     * @return
     * @throws NumberFormatException
     * @throws NullPointerException
     * @throws IOException
     * @throws NegativeValueException
     * @throws StartStopException
     */
    public static boolean alter(Trajet t) throws NumberFormatException, NullPointerException, IOException,
    NegativeValueException, StartStopException
    {
        List<String> traitement = SerializeText.recupererLignesOrdonnees();

        for(String s : traitement)
        {
            String[] token = SerializeText.getChaine(s);
            // Trouver la ligne cible
            if(token[0].equals("TRAJET") && token[1].equals(String.valueOf(t.getIdentTrajet())))
            {
                // Supprimer la ligne
                traitement.remove(s);
                // Ajouter la nouvelle ligne
                traitement.add(SerializeText.creerChaine(t.parse()));  
                // Recharger le fichier sans les champs précités
                SerializeText.ecrireLignes(traitement);
                SerializeText.ecrireLignes(SerializeText.recupererLignesOrdonnees());
                return true;
            }
        }
        return false;
    }

    /**
     * Récupérer les lignes du fichier texte cible
     * 
     * @return la liste des lignes du fichier de manière suivante (TRANSPORTS-TRAJETS-PARTICIPANTS)
     */
    public static List<String> recupererLignesOrdonnees()
    {
        // Créer trois liste pour définir l'ordre de transcription
        List<String> listeTransport = new ArrayList<String>();
        List<String> listeTrajet = new ArrayList<String>();
        List<String> listeVoyageur = new ArrayList<String>();

        // Definir un scanner sur le fichier
        Scanner scan = null;
        try{scan = new Scanner(new File(fichier));}
        catch(FileNotFoundException e){}

        // Initialiser un buffer pour contenir les lignes du fichier
        String buffer = null;

        // Parcourir l'ensemble du fichier
        while(scan.hasNextLine()) {
            // Lire la ligne courante du fichier
            buffer = scan.nextLine();
            String[] token = SerializeText.getChaine(buffer);

            // Ajouter les transports
            if(token[0].equals("TRANSPORT"))
            {
                listeTransport.add(buffer);
            }
            // Ajouter les trajets
            else if(token[0].equals("TRAJET"))
            {
                listeTrajet.add(buffer);
            }
            // Ajouter les voyageurs
            if(token[0].equals("VOYAGEUR"))
            {
                listeVoyageur.add(buffer);
            }
        }
        // Constuire la liste des lignes courantes par ordre prédéfini
        List<String> resultat = new ArrayList<String>();
        for(String s : listeTransport)
        {
            resultat.add(s);
        }
        for(String s : listeTrajet)
        {
            resultat.add(s);
        }
        for(String s : listeVoyageur)
        {
            resultat.add(s);
        }
        if (resultat.size() == 0)
            System.out.println("Il n'y a aucune donnée enregistrée dans le fichier");
        return resultat;
    }

    /**
     * Trier le fichier texte de la façon suivante :
     * 
     * Transports
     * Trajets
     * Voyageurs
     * @throws IOException 
     * @throws NullPointerException 
     * @throws StartStopException 
     * @throws NegativeValueException 
     * @throws NumberFormatException 
     * 
     */
    public static void ecrireLignes(List<String> ligne) throws NullPointerException, IOException,
    NumberFormatException, NegativeValueException, StartStopException
    {
        // Ecraser le fichier courant
        SerializeText.creerFichier();

        // Ajouter dans un premier temps les transports, puis les trajets puis les voyageurs
        for (String tri : ligne)
        {
            SerializeText.store(tri);
        }
    }

    /**
     * Retrouver un transport par un son identifiant
     * 
     * @param id
     * @return le transport s'il est trouvé, null sinon;
     */
    public static Transport getTransportById(int id)
    {
        Transport found = null;
        for(Transport tmp : transports)
        {
            if(tmp.getIdentTransport() == id)
                found = tmp;
        }
        return found;
    } 

    /**
     * Retrouver un transport par un son identifiant
     * 
     * @param id
     * @return le trajet s'il est trouvé, null sinon;
     */
    public static Trajet getTrajetById(int id)
    {
        Trajet found = null;
        for(Trajet tmp : trajets)
        {
            if(tmp.getIdentTrajet() == id)
                found = tmp;
        }
        return found;
    }

    /**
     * Récupérer tous les trajets ou un client est désigné voyageur
     * 
     * @param c
     *          Le client recherché
     * @return la liste des trajets retrouvés
     */
    public static List<Trajet> getTrajetsByClient(Client c)
    {
        List<Trajet> resultat = new ArrayList<Trajet>();
        for (Trajet t : trajets)
        {
            if(t.exists(c))
                resultat.add(t);
        }
        if(resultat.size() == 0)
            System.out.println("Aucun résultat trouvé pour le client de login " + c.getIdentifiant());
        return resultat;
    }

    /**
     * Récupérer tous les trajets qu'un transport effectue
     * 
     * @param t
     *          Le transport recherché
     * @return la liste des transports retrouvés
     */
    public static List<Trajet> getTrajetsByTransport(Transport t)
    {
        List<Trajet> resultat = new ArrayList<Trajet>();
        for (Trajet tr : trajets)
        {
            if(tr.getTransport().getIdentTransport() == t.getIdentTransport())
                resultat.add(tr);
        }
        return resultat;
    }

    /**
     * Récupérer les transports qui ont une place disponible pour un trajet d'une date donnée
     * @param d
     *          La date cible
     * @return la liste des transports trouvés
     */
    public static List<Transport> getTransportsByDate(Date d)
    {
        List<Transport> resultat = new ArrayList<Transport>();
        DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy à HH:mm");
        for (Trajet tr : trajets)
        {
            if(tr.existPlaces() && tr.getDate().equals(dateFormat.format(d))
                    && !resultat.contains(tr.getTransport()))
                resultat.add(tr.getTransport());
        }
        return resultat;
    }

    /**
     * Récupérer les transports qui  une place disponible pour un départ dans une ville donnée
     * @param v
     *          La ville cible
     * @return la liste des transports trouvés
     */
    public static List<Transport> getTransportsByVille(Ville v)
    {
        List<Transport> resultat = new ArrayList<Transport>();
        for (Trajet tr : trajets)
        {
            if(tr.existPlaces() && tr.getDepart().equals(v) && !resultat.contains(tr.getTransport()))
                resultat.add(tr.getTransport());
        }
        return resultat;
    }

    /**
     * Récupérer les trajets qui ont la même date
     * @param d
     *          La date cible
     * @return la liste des trajets trouvés
     */
    public static List<Trajet> getTrajetsByDate(Date d)
    {
        List<Trajet> resultat = new ArrayList<Trajet>();
        DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy à HH:mm");
        for (Trajet tr : trajets)
        {
            if(tr.getDate().equals(dateFormat.format(d)))
                resultat.add(tr);
        }
        return resultat;
    }

    /**
     * Récupérer les trajets qui ont la même ville de départ
     * @param v
     *          La ville cible
     * @return la liste des trajets trouvés
     */
    public static List<Trajet> getTrajetsByVille(Ville v)
    {
        List<Trajet> resultat = new ArrayList<Trajet>();
        for (Trajet tr : trajets)
        {
            if(tr.getDepart().equals(String.valueOf(v)))
                resultat.add(tr);
        }
        return resultat;
    }

    /**
     * Récupérer les trajets à partir d'une date de départ, pour un aller et un retour
     * @param d
     *          La ville de départ
     * @param a
     *          La ville d'arrivée
     * @param date
     *          La date de départ
     * @return la liste des trajets resultants de l'opération
     * @throws ParseException
     */
    @SuppressWarnings("deprecation")
    public static List<Trajet> getTrajetsLikeSncf(Ville d, Ville a, Date date) throws ParseException
    {
        List<Trajet> resultat = new ArrayList<Trajet>();
        for (Trajet tr : trajets)
        {
            if(tr.getDepart() == d && tr.getArrivee() == a
                    && Trajet.toFormatedDate(tr.getDate()).getYear() == date.getYear()
                    && Trajet.toFormatedDate(tr.getDate()).getMonth() == date.getMonth()
                    && Trajet.toFormatedDate(tr.getDate()).getDay() == date.getDay()
                    && date.getHours() <= Trajet.toFormatedDate(tr.getDate()).getHours()) 
                resultat.add(tr);
        }
        return resultat;
    }

}
